﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Windows.Forms;
using System.Globalization;
using System.Net;
using System.Xml.Serialization;
using System.Xml;

namespace LH.Utilitario
{
 
    public static class Libreria
    {
        #region --- Variables Globales ---
        /// <summary>
        /// Ruta donde se ejecuta el aplicativo
        /// </summary>
        public static string RutaApp = Directory.GetCurrentDirectory();
        #endregion

        #region --- Manejo de Rutas ---
        /// <summary>
        /// Metodo: Que permite agregar un Slash a una direccion
        /// </summary>
        /// <param name="sPath">Direccion</param>
        /// <returns>Resultado de agregar Slash</returns>
        public static string AddSlash(string sPath)
        {
            if (sPath.Substring(sPath.Length - 1, 1) != @"\") { sPath = sPath + @"\"; }
            return sPath;
        }

        /// <summary>
        /// Metodo: Que permite eliminar un Slash a una direccion
        /// </summary>
        /// <param name="sPath">Direccion</param>
        /// <returns>Resultado de eliminar Slash</returns>
        public static string QuitarSlash(string sPath)
        {
            if (sPath.Substring(sPath.Length - 1, 1) == @"\") { sPath = sPath.Substring(0, sPath.Length - 1); }
            return sPath;
        }
        #endregion

        #region --- Manejo de Archivo de Suceso ---
        /// <summary>
        /// Metodo: Que permite crear un archivo de texto en la carpeta de la aplicacion
        /// </summary>
        /// <param name="sSuceso">Suceso a escribir</param>
        public static void CrearSuceso(string sSuceso)
        {
            CrearSuceso(sSuceso, "|");
        }

        /// <summary>
        /// Metodo: Que permite crear un archivo de texto en la carpeta de la aplicacion
        /// </summary>
        /// <param name="sSuceso">Suceso a escribir</param>
        /// <param name="pSeparador">Separador de sucesos</param>
        public static void CrearSuceso(string sSuceso, string pSeparador)
        {
            string strNombreAssembly = System.Reflection.Assembly.GetExecutingAssembly().GetName().Name;
            StreamWriter strStreamWriter = null;
            string LogDirectorio = AddSlash(RutaApp);
            string LogSeparador = pSeparador;

            if (!Directory.Exists(LogDirectorio))
            {
                Directory.CreateDirectory(LogDirectorio);
            }

            string Hora = DateTime.Now.ToString("HH:mm:ss");
            string Fecha = DateTime.Now.ToString("yyyyMMdd");
            string ArchivoLog = LogDirectorio + strNombreAssembly + " - Sucesos_" + Fecha + ".log";

            if (!File.Exists(ArchivoLog))
            {
                strStreamWriter = new StreamWriter(ArchivoLog, false, System.Text.Encoding.Default);

                strStreamWriter.WriteLine("Fecha" + LogSeparador +
                                          "Hora" + LogSeparador +
                                          "Problema");

                strStreamWriter.WriteLine("-----" + LogSeparador +
                                          "-----" + LogSeparador +
                                          "-----");

            }
            else
            {
                strStreamWriter = new StreamWriter(ArchivoLog, true, System.Text.Encoding.Default);
            }

            strStreamWriter.WriteLine(Fecha + LogSeparador +
                                      Hora + LogSeparador +
                                      sSuceso);

            strStreamWriter.Close();
        }
        #endregion

        #region --- Metodos de manejo de Mensajes ---
        /// <summary>
        /// Metodo: Que emite un mensaje y da el foco al control
        /// </summary>
        /// <param name="oControl">Control a dar foco</param>
        /// <param name="Mensaje">Mensaje a emitirse</param>
        public static void CampoNecesario(Control oControl, string Mensaje)
        {
            CampoNecesario(oControl, Mensaje, "Faltan datos");
        }

        /// <summary>
        /// Metodo: Que emite un mensaje y da el foco al control
        /// </summary>
        /// <param name="oControl">Control a dar foco</param>
        /// <param name="Mensaje">Mensaje a emitirse</param>
        public static void CampoNecesario(ToolStripTextBox oControl, string Mensaje)
        {
            MessageBox.Show(Mensaje, "Faltan datos", MessageBoxButtons.OK, MessageBoxIcon.Asterisk, MessageBoxDefaultButton.Button1);
            oControl.Focus();
        }

        /// <summary>
        /// Metodo: Que emite un mensaje y da el foco al control
        /// </summary>
        /// <param name="oControl">Control a dar foco</param>
        /// <param name="Mensaje">Mensaje a emitirse</param>
        /// <param name="pTitulo">Titulo del mensaje</param>
        public static void CampoNecesario(Control oControl, string Mensaje, string pTitulo)
        {
            MessageBox.Show(Mensaje, pTitulo, MessageBoxButtons.OK, MessageBoxIcon.Asterisk, MessageBoxDefaultButton.Button1);
            oControl.Focus();
        }

        /// <summary>
        /// Metodo: Que emite un mensaje de error
        /// </summary>
        /// <param name="ex">Objeto de excepcion</param>
        public static void MensajeError(Exception ex)
        {
            MensajeError(ex, "Error");
        }

        /// <summary>
        /// Metodo: Que emite un mensaje de error
        /// </summary>
        /// <param name="ex">Objeto de excepcion</param>
        /// <param name="pTitulo">Titulo del mensaje</param>
        public static void MensajeError(Exception ex, string pTitulo)
        {
            string message;
            int num = ex.Message.IndexOf(">");
            //Strings.InStr(ex.Message, ">", CompareMethod.Binary);
            if (num > 0)
            {
                message = Mid(ex.Message, num + 1);
            }
            else
            {
                message = ex.Message;
            }
            MessageBox.Show(message, pTitulo, MessageBoxButtons.OK, MessageBoxIcon.Asterisk, MessageBoxDefaultButton.Button1);
        }

        /// <summary>
        /// Metodo: Que emite un mensaje de error
        /// </summary>
        /// <param name="Mensaje">Mensaje a emitirse</param>
        public static void ShowMessageboxError(string Mensaje)
        {
            ShowMessageboxError(Mensaje, "Error");
        }

        /// <summary>
        /// Metodo: Que emite un mensaje de error
        /// </summary>
        /// <param name="Mensaje">Mensaje a emitirse</param>
        /// <param name="Caption">Titulo del mensaje</param>
        public static void ShowMessageboxError(string Mensaje, string Caption)
        {
            MessageBox.Show(Mensaje, Caption, MessageBoxButtons.OK, MessageBoxIcon.Hand, MessageBoxDefaultButton.Button1);
        }

        /// <summary>
        /// Metodo: Que emite un mensaje de Exclamacion
        /// </summary>
        /// <param name="Mensaje">Mensaje a emitirse</param>
        public static void ShowMessageboxExclamacion(string Mensaje)
        {
            ShowMessageboxExclamacion(Mensaje, "Aviso..");
        }

        /// <summary>
        /// Metodo: Que emite un mensaje de Exclamacion
        /// </summary>
        /// <param name="Mensaje">Mensaje a emitirse</param>
        /// <param name="Caption">Titulo del mensaje</param>
        public static void ShowMessageboxExclamacion(string Mensaje, string Caption)
        {
            MessageBox.Show(Mensaje, Caption, MessageBoxButtons.OK, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1);
        }

        /// <summary>
        /// Metodo: Que emite un mensaje de Informacion
        /// </summary>
        /// <param name="Mensaje">Mensaje a emitirse</param>
        public static void ShowMessageboxInfo(string Mensaje)
        {
            ShowMessageboxInfo(Mensaje, "Información", 1);
        }

        /// <summary>
        /// Metodo: Que emite un mensaje de Informacion
        /// </summary>
        /// <param name="Mensaje">Mensaje a emitirse</param>
        /// <param name="Caption">Titulo del mensaje</param>
        public static void ShowMessageboxInfo(string Mensaje, string Caption)
        {
            ShowMessageboxInfo(Mensaje, Caption, 1);
        }

        /// <summary>
        /// Metodo: Que emite un mensaje de Informacion
        /// </summary>
        /// <param name="Mensaje">Mensaje a emitirse</param>
        /// <param name="Caption">Titulo del mensaje</param>
        /// <param name="pMostrar">Flag para mostrar Mensaje</param>
        public static void ShowMessageboxInfo(string Mensaje, string Caption, int pMostrar)
        {
            if (pMostrar != 0)
            {
                MessageBox.Show(Mensaje, Caption, MessageBoxButtons.OK, MessageBoxIcon.Asterisk, MessageBoxDefaultButton.Button1);
            }
        }

        /// <summary>
        /// Metodo: Que emite un mensaje de Pregunta
        /// </summary>
        /// <param name="Mensaje">Pregunta a emitirse</param>
        /// <returns>True=SI o False=NO</returns>
        public static bool ShowMessageboxPregunta(string Mensaje)
        {
            return ShowMessageboxPregunta(Mensaje, "Información");
        }

        /// <summary>
        /// Metodo: Que emite un mensaje de Pregunta
        /// </summary>
        /// <param name="Mensaje">Pregunta a emitirse</param>
        /// <param name="Caption">Titulo de la pregunta</param>
        /// <returns>True=SI o False=NO</returns>
        public static bool ShowMessageboxPregunta(string Mensaje, string Caption)
        {
            return MessageBox.Show(Mensaje, Caption, MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button1) == DialogResult.Yes ? true : false;
            //return BooleanType.FromObject(Interaction.IIf(MessageBox.Show(null,Mensaje, Caption, MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button1) == DialogResult.Yes, true, false));
        }

        #endregion

        #region --- Conversiones ---
        /// <summary>
        /// Metodo: Convierte de Hexadecimal a Binario
        /// </summary>
        /// <param name="hexvalue">Valor Hexa</param>
        /// <returns>Valor en Binario</returns>
        public static string Hex2Binary(string hexvalue)
        {
            int iLongitud = hexvalue.Length * 4;
            string binaryval = string.Empty;
            string dataAgregar = string.Empty;
            string cero = "0";

            //binaryval = Convert.ToString(Convert.ToInt32(hexvalue, 16), 2);
            binaryval = Convert.ToString(Convert.ToInt64(hexvalue, 16), 2);

            if (binaryval.Length < iLongitud)
            {
                //binaryval.PadLeft(iLongitud - binaryval.Length, '0');

                for (int i = 1; i <= (iLongitud - binaryval.Length); i++)
                {
                    dataAgregar += cero;
                }

                binaryval = dataAgregar + binaryval;
            }

            return binaryval;
        }

        /// <summary>
        /// Metodo: Convierte de Hexadecimal a Binario
        /// </summary>
        /// <param name="hex_string">Valor Hexa</param>
        /// <returns>Valor en Binario</returns>
        public static string HexToBinary(string hex_string)
        {
            string cero = "0";
            string uno = "1";
            hex_string = new string(Convert.ToChar(cero), 24 - hex_string.Length) + hex_string;

            string result_string = string.Empty;
            for (int digit_num = 0; digit_num <= 23; digit_num++)
            {
                // Convert this hexadecimal digit into a 
                // binary nibble. 
                int digit_value = int.Parse(hex_string.Substring(digit_num, 1), NumberStyles.HexNumber);

                // Convert the value into bits. 
                int factor = 8;
                string nibble_string = string.Empty;
                for (int bit = 0; bit <= 3; bit++)
                {
                    if (digit_value > 0 & factor > 0)
                    {
                        nibble_string += uno;
                    }
                    else
                    {
                        nibble_string += cero;
                    }
                    factor /= 2;
                }

                // Add the nibble's string to the left of the 
                // result string. 
                result_string += nibble_string;
            }

            return result_string;
        }

        /// <summary>
        /// Metodo: Convierte de Binario a Decimal
        /// </summary>
        /// <param name="bin">Valor Binario</param>
        /// <returns>Valor Decimal</returns>
        public static long BinaryToDecimal(string bin)
        {
            long l = Convert.ToInt64(bin, 2);
            //int i = (int)l;
            return l;
        }

        /// <summary>
        /// Metodo: Convierte de Binario a Decimal
        /// </summary>
        /// <param name="DatoBinario">Valor Binario</param>
        /// <returns>Valor Decimal</returns>
        public static long BinToDecimal(string DatoBinario)
        {
            long dato = 0;
            long temp = 0;
            for (int indice = 0; indice <= DatoBinario.Length - 1; indice++)
            {
                temp = Convert.ToInt32(DatoBinario[indice].ToString());
                if (temp == 1)
                {
                    dato += Convert.ToInt64(System.Math.Pow(2, DatoBinario.Length - 1 - indice));
                }
            }

            return dato;
        }

        /// <summary>
        /// Metodo: Convierte de Decimal a Hexadecimal
        /// </summary>
        /// <param name="decValue">Valor Decimal</param>
        /// <returns>Valor Hexa</returns>
        public static string Decimal2Hex(int decValue)
        {
            return decValue.ToString("X");
        }

        /// <summary>
        /// Metodo: Convierte de Hexadecimal a Decimal
        /// </summary>
        /// <param name="hexValue">Valor Hexa</param>
        /// <returns>Valor Decimal</returns>
        public static int Hex2Decimal(string hexValue)
        {
            return int.Parse(hexValue, NumberStyles.HexNumber);
        }

        /// <summary>
        /// Metodo: Convierte de Hexadecimal a Decimal
        /// </summary>
        /// <param name="hexValue">Valor Hexa</param>
        /// <returns>Valor Decimal</returns>
        public static decimal HexToDecimal(string hexValue)
        {
            return decimal.Parse(hexValue, NumberStyles.HexNumber); // .Parse(hexValue, NumberStyles.HexNumber);
        }

        /// <summary>
        /// Metodo: Convierte de Decimal a Binario 
        /// </summary>
        /// <param name="Decimal">Valor Decimal</param>
        /// <returns>Valor Binario</returns>
        public static string DecimalToBinary(Int64 Decimal)
        {
            // Declare a few variables we're going to need
            Int64 BinaryHolder;
            char[] BinaryArray;
            string BinaryResult = string.Empty;

            while (Decimal > 0)
            {
                BinaryHolder = Decimal % 2;
                BinaryResult += BinaryHolder;
                Decimal = Decimal / 2;
            }

            // The algoritm gives us the binary number in reverse order (mirrored)
            // We store it in an array so that we can reverse it back to normal
            BinaryArray = BinaryResult.ToCharArray();
            Array.Reverse(BinaryArray);
            BinaryResult = new string(BinaryArray);

            return BinaryResult;
        }

        /// <summary>
        /// Metodo: Convierte de Microsegundos a Fecha
        /// </summary>
        /// <param name="microseconds">Valor microsegundos</param>
        /// <returns>Valor Fecha</returns>
        private static DateTime GetDateTime(ulong microseconds)
        {
            DateTime epoc = new DateTime(1970, 1, 1, 0, 0, 0);

            long ticks = (long)microseconds * 10 + epoc.Ticks;

            return new DateTime(ticks, DateTimeKind.Utc);
        }
        #endregion

        #region --- Metodos de manejo de Cadenas ---
        /// <summary>
        /// Funcion que permite extraer los caracteres de un cadena empezando desde la derecha
        /// </summary>
        /// <param name="pCadena">Cadena de donde se le extraera los caracteres</param>
        /// <param name="Longitud">Longitud que se extraera de la Cadena</param>
        /// <returns>retorna los caracteres empezando de la derecha</returns>
        public static string Right(string pCadena, int Longitud)
        {
            if (Longitud < 0)
            {
                throw new ArgumentException("Argument_Longitud no puede ser 0");
            }
            if ((Longitud == 0) || (pCadena == null))
            {
                return "";
            }
            int length = pCadena.Length;
            if (Longitud >= length)
            {
                return pCadena;
            }
            return pCadena.Substring(length - Longitud, Longitud);
        }

        /// <summary>
        /// Funcion que permite extraer los caracteres de un cadena empezando desde la izquierda
        /// </summary>
        /// <param name="pCadena">Cadena de donde se le extraera los caracteres</param>
        /// <param name="Longitud">Longitud que se extraera de la Cadena</param>
        /// <returns>retorna los caracteres empezando de la izquierda</returns>
        public static string Left(string pCadena, int Longitud)
        {
            if (Longitud < 0)
            {
                throw new ArgumentException("Argument_Longitud no puede ser negativo");
            }
            if ((Longitud == 0) || (pCadena == null))
            {
                return "";
            }
            if (Longitud >= pCadena.Length)
            {
                return pCadena;
            }
            return pCadena.Substring(0, Longitud);
        }

        /// <summary>
        /// funcion que permite extraer un subcadena de una Cadena desde el parametro Inicio
        /// hasta el tamaño total de la cadena
        /// </summary>
        /// <param name="pCadena">Cadena a la que se extraera</param>
        /// <param name="Inicio">Indice desde donde se extraera la cadena</param>
        /// <returns>retorna la subcadena extraida</returns>
        public static string Mid(string pCadena, int Inicio)
        {
            string str2;
            try
            {
                if (pCadena == null)
                {
                    return null;
                }
                str2 = Mid(pCadena, Inicio, pCadena.Length);
            }
            catch (Exception exception)
            {
                throw exception;
            }
            return str2;
        }

        /// <summary>
        /// funcion que permite extraer un subcadena de una Cadena desde el parametro Inicio
        /// hasta el parametro Longitud
        /// </summary>
        /// <param name="pCadena">Cadena a la que se extraera</param>
        /// <param name="Inicio">Indice desde donde se extraera la cadena</param>
        /// <param name="Longitud">Longitud hasta donde se extraera la cadena</param>
        /// <returns>retorna la subcadena extraida</returns>
        public static string Mid(string pCadena, int Inicio, int Longitud)
        {
            if (Inicio <= 0)
            { throw new ArgumentException("Argument_Inicio No puede ser menor o igual a 0"); }
            if (Longitud < 0)
            { throw new ArgumentException("Argument_Longitud No puede ser menor a 0"); }

            if ((Longitud == 0) || (pCadena == null))
            {
                return "";
            }
            int length = pCadena.Length;
            if (Inicio > length)
            {
                return "";
            }
            if ((Inicio + Longitud) > length)
            {
                return pCadena.Substring(Inicio - 1);
            }
            return pCadena.Substring(Inicio - 1, Longitud);
        }
        #endregion

        #region --- Metodos de TiposDatos ---
        /// <summary>
        /// Funcion que permite ingresar solo numeros a textbox
        /// </summary>
        /// <param name="pTexto">TextBox que solo se permitira ingreso de numeros</param>
        /// <param name="e">Variable de evento KeyPressEventArgs</param>
        public static void SoloNumeros(TextBox pTexto, KeyPressEventArgs e)
        {
            SoloNumeros(pTexto, e, false, 2);
        }

        /// <summary>
        /// Funcion que permite ingresar solo numeros a textbox
        /// </summary>
        /// <param name="pTexto">TextBox que solo se permitira ingreso de numeros</param>
        /// <param name="e">Variable de evento KeyPressEventArgs</param>
        /// <param name="pDecimal">Flag que indica si se podra ingresar datos de tipo decimal</param>
        public static void SoloNumeros(TextBox pTexto, KeyPressEventArgs e, bool pDecimal)
        {
            SoloNumeros(pTexto, e, pDecimal, 2);
        }

        /// <summary>
        /// Funcion que permite ingresar solo numeros a textbox
        /// </summary>
        /// <param name="pTexto">TextBox que solo se permitira ingreso de numeros</param>
        /// <param name="e">Variable de evento KeyPressEventArgs</param>
        /// <param name="pDecimal">Flag que indica si se podra ingresar datos de tipo decimal</param>
        /// <param name="pDigitos">Cantidad de decimales a validarse</param>
        public static void SoloNumeros(TextBox pTexto, KeyPressEventArgs e, bool pDecimal, int pDigitos)
        {
            char backSpace = '\b';
            char signoNegativo = '-';
            char puntoDecimal = '.';

            if (e.KeyChar != backSpace)
            {
                if (e.KeyChar.Equals(signoNegativo))
                {
                    pTexto.Text = signoNegativo.ToString();
                    pTexto.SelectionStart = 1;
                    e.Handled = true;
                }
                else
                {
                    if (pTexto.Text.IndexOf(signoNegativo) > -1)
                    {
                        e.Handled = true;
                    }
                }

                if (!char.IsNumber(e.KeyChar))
                {
                    if (e.KeyChar.Equals(puntoDecimal) & pDecimal)
                    {
                        if (pTexto.Text.IndexOf(puntoDecimal) > -1)
                        {
                            e.Handled = true;
                        }
                        return;
                    }
                    e.Handled = true;
                    return;
                }

                if (pTexto.Text.IndexOf(puntoDecimal.ToString()) > -1)
                {
                    if (pTexto.SelectionStart > pTexto.Text.IndexOf(puntoDecimal))
                    {
                        string str = pTexto.Text.Split(puntoDecimal)[1];
                        if (str.Length >= pDigitos)
                        {
                            e.Handled = true;
                        }
                    }
                }
            }
            //return obj2;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="pTexto"></param>
        /// <param name="e"></param>
        /// <param name="pCodigoEP"></param>
        /// <param name="pTipo"></param>
        public static void SoloEspecial(TextBox pTexto, KeyPressEventArgs e, string pCodigoEP, ref int pTipo)
        {
            int CarAsc = 0;
            try
            {
                if (pCodigoEP.Equals("PDB"))
                {
                    if (pTexto.Text.Trim().Length == 0)
                    {
                        // primer caracter de ingreso puede ser alfa o numerico
                        CarAsc = (int)(e.KeyChar);
                        if (CarAsc >= 47 & CarAsc <= 57) { }
                        else if (CarAsc >= 65 & CarAsc <= 90) { }
                        else if (CarAsc == 8) { }
                        else
                        {
                            e.Handled = true;
                        }
                    }
                    else
                    {
                        if (char.IsNumber(pTexto.Text.Trim().Substring(0, 1).ToCharArray()[0]))
                        {
                            Codigo_Basico(e, pTexto);
                            pTipo = 1;
                        }
                        else
                        {
                            Codigo_Letras(e);
                            pTipo = 0;
                        }
                    }
                }
                else
                {
                    Codigo_Basico(e, pTexto);
                }
            }
            catch
            {
                throw;
            }
        }

        private static void Codigo_Letras(KeyPressEventArgs e)
        {
            // ingreso de solo letras Mayusculas
            int CarAsc = 0;
            CarAsc = (int)(e.KeyChar);
            if (CarAsc >= 65 & CarAsc <= 90) { }
            else if (CarAsc == 8) { }
            else
            { e.Handled = true; }
        }

        private static void Codigo_Basico(KeyPressEventArgs e, TextBox pTexto)
        {
            string cad = string.Empty;
            int CarAsc = 0;
            CarAsc = (int)(e.KeyChar);
            if (CarAsc >= 47 & CarAsc <= 57) { }
            else if (CarAsc == 120 | CarAsc == 8) { }
            else
            {
                e.Handled = true;
            }
            //valida que no se ingrese "/" o "x" al inicio de la cadena
            cad = pTexto.Text.Trim();

            if (cad.Length == 0)
            {
                if (CarAsc == 47 | CarAsc == 120)
                {
                    e.Handled = true;
                }
                else
                    //valida que no se ingresen dos operadores (/ , x) juntos
                    if (CarAsc == 47 | CarAsc == 120)
                    {
                        string sStr = Mid(cad, cad.Length, 1);
                        if (string.Equals(sStr, "/") | string.Equals(sStr, "x"))
                        {
                            e.Handled = true;
                        }
                    }
            }
        }

        /// <summary>
        /// Funcion que permite ingresar solo numeros a textbox
        /// </summary>
        /// <param name="pTexto">TextBox que solo se permitira ingreso de numeros</param>
        /// <param name="e">Variable de evento KeyPressEventArgs</param>
        public static void ValidarNumeros(TextBox pTexto, KeyPressEventArgs e)
        {
            ValidarNumeros(pTexto, e, false, 2);
        }

        /// <summary>
        /// Funcion que permite ingresar solo numeros a textbox
        /// </summary>
        /// <param name="pTexto">TextBox que solo se permitira ingreso de numeros</param>
        /// <param name="e">Variable de evento KeyPressEventArgs</param>
        /// <param name="pDecimal">Flag que indica si se podra ingresar datos de tipo decimal</param>
        public static void ValidarNumeros(TextBox pTexto, KeyPressEventArgs e, bool pDecimal)
        {
            ValidarNumeros(pTexto, e, pDecimal, 2);
        }

        /// <summary>
        /// Funcion que permite ingresar solo numeros a textbox
        /// </summary>
        /// <param name="pTexto">TextBox que solo se permitira ingreso de numeros</param>
        /// <param name="e">Variable de evento KeyPressEventArgs</param>
        /// <param name="pDecimal">Flag que indica si se podra ingresar datos de tipo decimal</param>
        /// <param name="pDigitos">Cantidad de decimales a validarse</param>
        public static void ValidarNumeros(TextBox pTexto, KeyPressEventArgs e, bool pDecimal, int pDigitos)
        {
            //object obj2=null;
            if (e.KeyChar != '\b')
            {
                if (!char.IsNumber(e.KeyChar))
                {
                    if (e.KeyChar.ToString().Equals(".") & pDecimal)
                    {
                        if (pTexto.Text.IndexOf(".") > -1)
                        {
                            e.Handled = true;
                        }
                        return;
                    }
                    e.Handled = true;
                    return;
                }

                if (pTexto.Text.IndexOf(".") > -1)
                {
                    if (pTexto.SelectionStart > pTexto.Text.IndexOf("."))
                    {
                        string str = pTexto.Text.Split('.')[1];
                        if (str.Length >= pDigitos)
                        {
                            e.Handled = true;
                        }
                    }
                }
            }
            //return obj2;
        }


        /// <summary>
        /// Funcion que permite ingresar solo numeros reales a textbox
        /// </summary>
        /// <param name="pTexto">TextBox que solo se permitira ingreso de numeros</param>
        /// <param name="e">Variable de evento KeyPressEventArgs</param>
        public static void ValidarReales(TextBox pTexto, KeyPressEventArgs e)
        {
            ValidarNumeros(pTexto, e, false, 2);
        }

        /// <summary>
        /// Funcion que permite ingresar solo numeros reales a textbox
        /// </summary>
        /// <param name="pTexto">TextBox que solo se permitira ingreso de numeros</param>
        /// <param name="e">Variable de evento KeyPressEventArgs</param>
        /// <param name="pDecimal">Flag que indica si se podra ingresar datos de tipo decimales</param>
        public static void ValidarReales(TextBox pTexto, KeyPressEventArgs e, bool pDecimal)
        {
            ValidarReales(pTexto, e, pDecimal, 2);
        }

        /// <summary>
        /// Funcion que permite ingresar solo numeros reales a textbox
        /// </summary>
        /// <param name="pTexto">TextBox que solo se permitira ingreso de numeros</param>
        /// <param name="e">Variable de evento KeyPressEventArgs</param>
        /// <param name="pDecimal">Flag que indica si se podra ingresar datos de tipo decimales</param>
        /// <param name="pDigitos">Cantidad de decimales a validarse</param>
        public static void ValidarReales(TextBox pTexto, KeyPressEventArgs e, bool pDecimal, int pDigitos)
        {
            //object obj2=null;
            if (e.KeyChar != '\b')
            {
                if (e.KeyChar.Equals('-'))
                {
                    if (pTexto.Text.IndexOf("-") > -1)
                    {
                        e.Handled = true;
                    }
                    else
                    {
                        if (pTexto.SelectionStart != 0)
                        {
                            e.Handled = true;
                        }
                        else
                        {
                            //							pTexto.Text = "-" + pTexto.Text;
                            //							pTexto.SelectionStart = 1;
                            e.Handled = false;
                        }
                    }
                    return;
                }

                if (!char.IsNumber(e.KeyChar))
                {
                    if (e.KeyChar.ToString().Equals(".") & pDecimal)
                    {
                        if (pTexto.Text.IndexOf(".") > -1)
                        {
                            e.Handled = true;
                        }
                        return;
                    }
                    e.Handled = true;
                    return;
                }

                if (pTexto.Text.IndexOf(".") > -1)
                {
                    if (pTexto.SelectionStart > pTexto.Text.IndexOf("."))
                    {
                        string str = pTexto.Text.Split('.')[1];
                        if (str.Length >= pDigitos)
                        {
                            e.Handled = true;
                        }
                    }
                }
            }
            //return obj2;
        }
        #endregion

        #region --- Metodos NetWork ---
        /// <summary>
        /// Metodo: Que permite obtener el IP de la Pc
        /// </summary>
        /// <returns>IP</returns>
        public static string IpAddress()
        {
            return Dns.GetHostEntry(Dns.GetHostName()).AddressList[0].ToString();
        }
        #endregion

        #region --- Metodos ComprobrarConexionWEB ---
        /// <summary>
        /// Check (HTTP) connection once.
        /// </summary>
        /// <param name="targetAddress">Target address (URL or IP) to check</param>
        /// <param name="bMostrarException">Flag que indica si se lanzara un excepcion en caso de provocarse un error</param>
        /// <returns>Whether connection exist to target address</returns>
        public static bool VerficarConexionWeb(string targetAddress, bool bMostrarException)
        {
            HttpWebRequest request = null;
            HttpWebResponse response = null;
            bool isConnected = false;

            try
            {
                request = (HttpWebRequest)WebRequest.Create(targetAddress);
                response = (HttpWebResponse)request.GetResponse();
                request.Abort();

                // success?
                if (response.StatusCode == HttpStatusCode.OK)
                {
                    isConnected = true;
                }
                response.GetResponseStream().Close();
            }
            catch (WebException we)
            {
                //string errMsg = we.Message;
                //isConnected = false;
                if (bMostrarException) { throw (we); }
            }
            catch (Exception ex)
            {
                //string errMsg = ex.Message;
                //isConnected = false;
                if (bMostrarException) { throw (ex); }
            }
            finally
            {
                if (request != null) { request = null; }
                if (response != null) { response = null; }
            }
            return isConnected;
        }

        /// <summary>
        /// Check (HTTP) connection a specified number of times.
        /// </summary>
        /// <param name="targetAddress">Target address (URL or IP) to check</param>
        /// <param name="timesToCheck">Maximum number of times to check</param>
        /// <returns>Whether connection exist to target address</returns>
        public static bool VerficarConexion_MultipleWeb(string targetAddress, int timesToCheck)
        {
            for (int i = 0; i < timesToCheck; i++)
                if (VerficarConexionWeb(targetAddress, false))
                    return true;
            return false;
        }
        #endregion

        #region --- Metodos Formato ---
        private static string FormatoEpc(string epc)
        {
            string resultado = string.Empty;

            if (epc.Length <= 4)
            {
                resultado = epc;
            }
            else if (epc.Length > 4 && epc.Length <= 8)
            {
                resultado = string.Format("{0}-{1}", epc.Substring(0, 4), epc.Substring(4));
            }
            else if (epc.Length > 8 && epc.Length <= 12)
            {
                resultado = string.Format("{0}-{1}-{2}", epc.Substring(0, 4), epc.Substring(4, 4), epc.Substring(8));
            }
            else if (epc.Length > 12 && epc.Length <= 16)
            {
                resultado = string.Format("{0}-{1}-{2}-{3}", epc.Substring(0, 4), epc.Substring(4, 4), epc.Substring(8, 4), epc.Substring(12));
            }
            else if (epc.Length > 16 && epc.Length <= 20)
            {
                resultado = string.Format("{0}-{1}-{2}-{3}-{4}", epc.Substring(0, 4), epc.Substring(4, 4), epc.Substring(8, 4), epc.Substring(12, 4), epc.Substring(16));
            }
            else if (epc.Length > 20 && epc.Length <= 24)
            {
                resultado = string.Format("{0}-{1}-{2}-{3}-{4}-{5}", epc.Substring(0, 4), epc.Substring(4, 4), epc.Substring(8, 4), epc.Substring(12, 4), epc.Substring(16, 4), epc.Substring(20));
            }

            return resultado;
        }
        #endregion

       
    }

}
